<script>
	/*
	 Promise
	 他是一个构造函数
	 返回值
	     构造调用该函数可以得到他的实例对象(promise对象)
	     promise对象具有3种状态
	         pending->等待(初始状态)
	         resolved->成功
	         rejected->失败

	         注意:promise的状态只会发生一次变化,而且该变化不可逆
	 接收参数(1个)
	     数据类型:函数
	     接收一个执行器函数
	         该回调函数接收两个参数
	             resolve ->  调用该函数将返回的promise对象状态变为成功状态
	             reject ->  调用该函数将返回的promise对象状态变为失败状态

	     注意:该执行器函数会被同步调用

	 .then
	 .then会根据前面被监视的promise的状态执行对应的回调函数
	 接收参数(2个)
	     数据类型:函数
	     第一个函数是当被监视的promise状态为成功状态,才会执行
	     第二个函数是当被监视的promise状态为失败状态,才会执行

	     在执行回调函数的同时,会将被监视的promise的result值作为实参传递给回调函数

	     注意:如果在执行对应回调函数的时候,没有可执行函数,那么当前.then返回的promise的状态会参考被监视的promise的状态

	 返回值
	     全新的promise对象(p2)
	       如何让p2状态发生变化
	         变为成功
	             1.当回调函数中的代码顺利执行结束,那么返回的p2对象的状态就会变为成功状态
	                 此情况,相当于return undefined
	             2.当回调函数返回一个成功的promise对象时,那么返回的p2对象的状态就会变为成功状态
	                 当回调函数返回的是非promise对象时,那么返回的数据就会变成p2的result

	         变为失败
	             1.当回调函数中的代码无法顺利执行结束(出现报错),那么返回的p2对象的状态就会变为失败状态
	             2.当回调函数返回一个失败的promise对象时,那么返回的p2对象的状态就会变为失败状态

	         注意:.then执行成功或者失败回调函数,都不会影响到当前返回的p2的状态

	 .catch 
    接收参数(1个)
	     数据类型:函数
	     函数是当被监视的promise状态为失败捕获状态,才会执行
	 .catch可以监视前面promise的状态变化,如果该promise变为失败状态,就会执行回调函数
	 .catch其实是.then的语法糖
	 它相当于
	     p1.then(undefined,()=>{})
			*/
	var eg1 = () => {
		// 例子一: promise的状态不可逆;
		var promise = new Promise(function (resolve, reject) {
			// promise对象会同步变为成功状态
			setTimeout(() => {
				resolve();
			}, 0);
			setTimeout(() => {
				reject();
			}, 1000);
		});
		setTimeout(() => {
			console.log(promise);
		}, 2000);
	};

	// eg1();

	var eg2 = () => {
		// 例子2:回调函数的返回值,不能够影响到.then的返回值,
		// .then永远返回的都是全新promise对象
		var p1 = new Promise(function (resolve, reject) {
			setTimeout(reject, 1000, 345);
			// setTimeout(()=>{
			//     resolve(123);
			// },1000)
		});
		var p2 = p1.then(
			function () {
				console.log("success");
				return "success";
			},
			function () {
				console.log("error");
				return "error";
			}
		);
		console.log(p2);
	};

	// eg2();

	var eg3 = () => {
		var p1 = new Promise(function (resolve, reject) {
			setTimeout(reject, 1000, 345);
		});
		// 例子3:.then返回的promise和被监视的promise不是同一个对象
		var p2 = p1.then(
			function () {
				console.log("success");
			},
			function () {
				console.log("error");
			}
		);
		console.log(p2 === p1);
	};
	// eg3();

	var eg4 = () => {
		// 例子4:该例子用于研究回调函数的返回值对p2对象的影响
		var p1 = new Promise(function (resolve, reject) {
			setTimeout(reject, 1000, 345);
		});

		var p3 = Promise.resolve();
		var p2 = p1.then(
			function () {
				console.log("success");
				// throw new Error();
				// return p3;
				return "returnSuccess";
			},
			function () {
				return "returnError";
				console.log("error");
			}
		);
		console.log(p2);
	};
	// eg4();

	var eg5 = () => {
		// 例子5:此例子用于研究回调函数与p2之间的关系
		// 注意:.then执行成功或者失败回调函数,都不会影响到当前返回的p2的状态
		var p1 = new Promise(function (resolve, reject) {
			setTimeout(reject, 1000, 345);
		});
		p1.then(
			function () {
				console.log(1, "success1");
			},
			function () {
				console.log(2, "error2");
				return Promise.reject();
			}
		).then(
			function () {
				console.log(3, "success1");
			},
			function () {
				console.log(4, "error2");
			}
		);
	};
	// eg5();

	var eg6 = () => {
		var p1 = new Promise(function (resolve, reject) {
			setTimeout(reject, 1000, 345);
		});
		// 例子6:用于研究如果监视的promise发生变化,没有对应的回调函数会如何
		p1.then(
			function () {
				console.log(1, "success1");
			}
			// ,
			// function () {
			// 	console.log(2, "error");
			// }
		)
			.then(
				function () {
					console.log(3, "success1");
				}
				// ,
				// function () {
				// 	console.log(4, "error");
				// }
			)
			.catch(function () {
				console.log(5, "error");
			});
	};
	eg6();

	// 扩展：Promise.all([promise1, promise2, promise3])
	/*
  - 批量/一次性发送多个异步请求
  - 当都成功时, 返回的promise才成功
  - 一旦有一个失败的, 返回的promise就失败了
问题: 发3请求成功后再4个请求 */

	// 扩展：Promise.race([promise1, promise2, promise3])
	// 批量/一次性发送多个异步请求，谁先回来就用是的结果
</script>
